Kotlin 简介和特性

1. Kotlin 简介

Kotlin 是一种现代的、静态类型的编程语言，由 JetBrains 开发，旨在与 Java 完全互操作。Kotlin 可以编译成 Java 字节码，也可以编译成 JavaScript，使其在多种平台上都能使用。Kotlin 的设计目标是简洁、安全和互操作性，使其成为 Android 开发的首选语言之一。

1.1 Kotlin 的历史

Kotlin 于 2011 年由 JetBrains 首次公布，并于 2016 年正式发布 1.0 版本。2017 年，Google 宣布 Kotlin 成为 Android 开发的官方语言之一，这大大推动了 Kotlin 的普及。

1.2 Kotlin 的特性

简洁性：Kotlin 减少了样板代码，使代码更简洁易读。
安全性：Kotlin 通过可空类型和非空类型减少了 NullPointerException 的发生。
互操作性：Kotlin 与 Java 完全互操作，可以无缝调用 Java 代码，反之亦然。
多平台支持：Kotlin 不仅可以用于 Android 和 JVM，还可以用于 JavaScript 和 Native 平台。

2. 开发环境搭建

2.1 安装 IntelliJ IDEA

IntelliJ IDEA 是 JetBrains 开发的集成开发环境，支持 Kotlin 开发。你可以从 JetBrains 官网下载并安装 IntelliJ IDEA。

2.2 安装 Android Studio

Android Studio 是 Google 提供的官方 Android 开发环境，基于 IntelliJ IDEA，支持 Kotlin 开发。你可以从 Android 开发者官网下载并安装 Android Studio。

3. 第一个 Kotlin 程序

让我们编写第一个 Kotlin 程序，输出 "Hello, Kotlin!"。

fun main() {
    println("Hello, Kotlin!")
}

3.1 代码解释

fun main()：定义了一个名为 main 的函数，这是 Kotlin 程序的入口点。
println("Hello, Kotlin!")：输出字符串 "Hello, Kotlin!" 到控制台。

4. 基本语法和数据类型

4.1 变量和常量

在 Kotlin 中，你可以使用 var 定义可变变量，使用 val 定义不可变常量。

var age: Int = 25
val name: String = "Kotlin"

4.2 数据类型

Kotlin 支持多种数据类型，包括：

数字类型：Int, Long, Float, Double
字符类型：Char
布尔类型：Boolean
字符串类型：String

5. 条件语句

5.1 if 语句

val number = 10
if (number > 5) {
    println("Number is greater than 5")
} else {
    println("Number is 5 or less")
}

5.2 when 语句

when 语句类似于 Java 中的 switch 语句，但功能更强大。

val day = "Monday"
when (day) {
    "Monday" -> println("It's Monday")
    "Tuesday" -> println("It's Tuesday")
    else -> println("It's another day")
}

6. 循环

6.1 for 循环

for (i in 1..5) {
    println(i)
}

6.2 while 循环

var i = 1
while (i <= 5) {
    println(i)
    i++
}

6.3 do-while 循环

var i = 1
do {
    println(i)
    i++
} while (i <= 5)

7. 跳转表达式

7.1 break

break 用于终止循环。

for (i in 1..10) {
    if (i == 5) {
        break
    }
    println(i)
}

7.2 continue

continue 用于跳过当前循环的剩余部分，继续下一次循环。

for (i in 1..5) {
    if (i == 3) {
        continue
    }
    println(i)
}

7.3 return

return 用于从函数中返回值。

fun add(a: Int, b: Int): Int {
    return a + b
}

8. 函数定义和调用

8.1 函数定义

fun greet(name: String): String {
    return "Hello, $name!"
}

8.2 函数调用

val greeting = greet("Kotlin")
println(greeting)

9. 默认参数和命名参数

9.1 默认参数

fun greet(name: String = "World"): String {
    return "Hello, $name!"
}

9.2 命名参数

val greeting = greet(name = "Kotlin")
println(greeting)

10. 单表达式函数

fun add(a: Int, b: Int) = a + b

11. Lambda 表达式

val sum = { x: Int, y: Int -> x + y }
println(sum(1, 2))

12. 高阶函数

fun operate(a: Int, b: Int, operation: (Int, Int) -> Int): Int {
    return operation(a, b)
}

val result = operate(3, 4) { x, y -> x * y }
println(result)

13. 类定义和实例化

13.1 类定义

class Person(val name: String, var age: Int)

13.2 实例化

val person = Person("Kotlin", 25)
println("Name: ${person.name}, Age: ${person.age}")

14. 构造函数和初始化块

14.1 主构造函数

class Person(val name: String, var age: Int) {
    init {
        println("Person initialized with name: $name and age: $age")
    }
}

14.2 次构造函数

class Person(val name: String, var age: Int) {
    constructor(name: String) : this(name, 0)
}

15. 属性和字段

class Person(val name: String, var age: Int) {
    var address: String = ""
        get() = field
        set(value) {
            field = value
        }
}

16. 继承和接口

16.1 继承

open class Animal(val name: String)

class Dog(name: String) : Animal(name)

16.2 接口

interface Greeter {
    fun greet(name: String): String
}

class Person(val name: String) : Greeter {
    override fun greet(name: String): String {
        return "Hello, $name!"
    }
}

17. 数据类和密封类

17.1 数据类

data class User(val name: String, val age: Int)

17.2 密封类

sealed class Result
data class Success(val data: String) : Result()
data class Error(val message: String) : Result()

18. 对象声明和表达式

18.1 对象声明

object Singleton {
    val name = "Singleton"
}

18.2 对象表达式

val greeter = object : Greeter {
    override fun greet(name: String): String {
        return "Hello, $name!"
    }
}

19. 可空类型和非空类型

19.1 可空类型

var name: String? = null

19.2 非空类型

var name: String = "Kotlin"

20. 安全调用操作符 (?.)

val length = name?.length

21. Elvis 操作符 (?:)

val length = name?.length ?: 0

22. 非空断言 (!!)

val length = name!!.length

23. 平台类型

val name: String! = "Kotlin"

24. List, Set, Map

24.1 List

val list = listOf("Kotlin", "Java", "Python")

24.2 Set

val set = setOf("Kotlin", "Java", "Python")

24.3 Map

val map = mapOf("Kotlin" to 1, "Java" to 2, "Python" to 3)

25. 可变集合和不可变集合

25.1 可变集合

val mutableList = mutableListOf("Kotlin", "Java", "Python")
mutableList.add("C++")

25.2 不可变集合

val immutableList = listOf("Kotlin", "Java", "Python")

26. 集合操作 (filter, map, reduce 等)

26.1 filter

val filteredList = list.filter { it.length > 4 }

26.2 map

val mappedList = list.map { it.toUpperCase() }

26.3 reduce

val sum = list.map { it.length }.reduce { acc, i -> acc + i }

27. 序列 (Sequence)

val sequence = sequenceOf("Kotlin", "Java", "Python")
val result = sequence.filter { it.length > 4 }.map { it.toUpperCase() }.toList()

28. 不可变性

val immutableList = listOf("Kotlin", "Java", "Python")

29. 纯函数

fun add(a: Int, b: Int): Int {
    return a + b
}

30. 函数组合

fun compose(f: (Int) -> Int, g: (Int) -> Int): (Int) -> Int {
    return { x -> f(g(x)) }
}

31. 柯里化

fun add(a: Int) = { b: Int -> a + b }

32. 协程基础

import kotlinx.coroutines.*

fun main() = runBlocking {
    launch {
        delay(1000L)
        println("World!")
    }
    println("Hello,")
}

33. 挂起函数

suspend fun fetchData(): String {
    delay(1000L)
    return "Data"
}

34. 协程上下文和调度器

import kotlinx.coroutines.*

fun main() = runBlocking {
    launch(Dispatchers.IO) {
        println("Running on ${Thread.currentThread().name}")
    }
}

35. 通道和流

import kotlinx.coroutines.*
import kotlinx.coroutines.channels.*

fun main() = runBlocking {
    val channel = Channel<Int>()
    launch {
        for (x in 1..5) channel.send(x * x)
        channel.close()
    }
    for (y in channel) println(y)
}

36. 异步编程模式

import kotlinx.coroutines.*

fun main() = runBlocking {
    val deferred = async {
        delay(1000L)
        "Result"
    }
    println(deferred.await())
}

37. 泛型函数和类

37.1 泛型函数

fun <T> printList(list: List<T>) {
    for (item in list) {
        println(item)
    }
}

37.2 泛型类

class Box<T>(val item: T)

38. 型变（协变和逆变）

38.1 协变

class Box<out T>(val item: T)

38.2 逆变

class Box<in T> {
    fun setItem(item: T) {}
}

39. 类型投影

fun copy(from: Array<out Any>, to: Array<Any>) {
    for (i in from.indices) {
        to[i] = from[i]
    }
}

40. 泛型约束

fun <T : Comparable<T>> max(a: T, b: T): T {
    return if (a > b) a else b
}

41. 属性委托

class Example {
    var p: String by Delegate()
}

class Delegate {
    operator fun getValue(thisRef: Any?, property: KProperty<*>): String {
        return "$thisRef, thank you for delegating '${property.name}' to me!"
    }

    operator fun setValue(thisRef: Any?, property: KProperty<*>, value: String) {
        println("$value has been assigned to '${property.name}' in $thisRef.")
    }
}

42. 类委托

interface Base {
    fun print()
}

class BaseImpl(val x: Int) : Base {
    override fun print() { print(x) }
}

class Derived(b: Base) : Base by b

43. 标准委托 (lazy, observable 等)

43.1 lazy

val lazyValue: String by lazy {
    println("Computed!")
    "Hello"
}

43.2 observable

import kotlin.properties.Delegates

var name: String by Delegates.observable("<no name>") {
    prop, old, new ->
    println("$old -> $new")
}

44. 类引用

val c = MyClass::class

45. 可调用引用

val numbers = listOf(1, 2, 3)
println(numbers.filter(::isOdd))

fun isOdd(x: Int) = x % 2 != 0

46. 属性引用

val prop = MyClass::myProperty
println(prop.get(MyClass()))

47. 反射 API

import kotlin.reflect.full.*

class MyClass {
    var myProperty: String = "Hello"
}

fun main() {
    val kClass = MyClass::class
    kClass.declaredMemberProperties.forEach { println(it.name) }
}

← Previous: 01. 基础入门 Next: 开发环境搭建：IntelliJ IDEA与Android Studio →